home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 13 - 1997 (partial) / 13.05 May 97 / TidyHeap / CTidyHeapFile_AC.cp < prev    next >
Encoding:
Text File  |  1997-04-14  |  7.5 KB  |  293 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // CTidyHeapFile_AC.cp
  3. // Copyright © 1984-97 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __CTidyHeap_AC__
  7. #include "CTidyHeap_AC.h"
  8. #endif
  9.  
  10. #if qTidyHeap
  11.  
  12. #ifndef _STRING
  13. #include <string.h>
  14. #endif
  15.  
  16. // toolbox
  17.  
  18. #ifndef __ERRORS__
  19. #include <Errors.h>
  20. #endif
  21.  
  22. #ifndef __TEXTUTILS__
  23. #include <TextUtils.h>
  24. #endif
  25. // tidyheap
  26.  
  27. #ifndef __CTidyHeapFile_AC__
  28. #include "CTidyHeapFile_AC.h"
  29. #endif
  30.  
  31. //========================================================================================
  32. // class CTidyHeapFile_AC
  33. //========================================================================================
  34.  
  35. //----------------------------------------------------------------------------------------
  36. // Default Constructor
  37. //----------------------------------------------------------------------------------------
  38.  
  39. CTidyHeapFile_AC::CTidyHeapFile_AC() :
  40. fErr(0),
  41. fRef(0)
  42. {
  43.     fType = 'TEXT';
  44.     fCreator = 'MPS ';
  45.     
  46.     CTidyHeap_AC::Instance()->GetSessionFileLoc(fSpec.vRefNum,fSpec.parID);
  47.     
  48.     StringPtr sName = (StringPtr) CTidyHeap_AC::Instance()->GetSessionName();
  49.     
  50.     pstrcpy(fSpec.name,sName);
  51. }
  52.  
  53. //----------------------------------------------------------------------------------------
  54. // Copy Constructor
  55. //----------------------------------------------------------------------------------------
  56.  
  57. CTidyHeapFile_AC::CTidyHeapFile_AC(const CTidyHeapFile_AC &inFile)
  58. {
  59.     *this = inFile;
  60. }
  61.  
  62. //----------------------------------------------------------------------------------------
  63. // Conversion Constructor
  64. //----------------------------------------------------------------------------------------
  65.  
  66. CTidyHeapFile_AC::CTidyHeapFile_AC(const FSSpec &inSpec) :
  67. fErr(0),
  68. fRef(0)
  69. {
  70.     fType = 'TEXT';
  71.     fCreator = 'MPS ';
  72.     CopySpec( &fSpec, &inSpec );
  73. }
  74.  
  75. //----------------------------------------------------------------------------------------
  76. // Destructor
  77. //----------------------------------------------------------------------------------------
  78.  
  79. CTidyHeapFile_AC::~CTidyHeapFile_AC()
  80. {
  81.     if(IsOpen())
  82.         Close();
  83. }
  84.  
  85. //----------------------------------------------------------------------------------------
  86. // CTidyHeapFile_AC::Open
  87. //----------------------------------------------------------------------------------------
  88.  
  89. void CTidyHeapFile_AC::Open(ePerms inPerms)
  90. {
  91.     if( !fRef )
  92.     {
  93.         char perms = inPerms == kRead ? fsRdPerm : fsRdWrPerm;
  94.             
  95.         fErr = ::FSpOpenDF( &fSpec, perms, &fRef);
  96.         
  97.         if(fErr == fnfErr && perms == fsRdWrPerm) 
  98.         {
  99.             fErr =  ::FSpCreate( &fSpec,fCreator, fType,  0);
  100.  
  101.             if(!fErr)
  102.                 fErr = ::FSpOpenDF( &fSpec, perms, &fRef);
  103.         }    
  104.         
  105.         
  106.         if(!fErr)
  107.         {
  108.             if(inPerms == kAppend)
  109.                 fErr = ::SetFPos(fRef,fsFromLEOF,0);
  110.             else
  111.             if(inPerms == kWrite)
  112.                 fErr = ::SetEOF(fRef, 0);
  113.         }
  114.     }
  115. }
  116.  
  117.  
  118. //----------------------------------------------------------------------------------------
  119. // CTidyHeapFile_AC::Close
  120. //----------------------------------------------------------------------------------------
  121.  
  122. void CTidyHeapFile_AC::Close()
  123. {
  124.     if(fRef)
  125.     {
  126.         fErr = FSClose(fRef);
  127.         if(!fErr) fRef = 0;
  128.     }
  129. }
  130.  
  131. //----------------------------------------------------------------------------------------
  132. // CTidyHeapFile_AC::Read
  133. //----------------------------------------------------------------------------------------
  134.  
  135. long CTidyHeapFile_AC::Read(char *data, long size )
  136. {
  137.     if(fRef)
  138.         fErr = ::FSRead( fRef,  &size, (Ptr) data );
  139.     else
  140.         fErr = fnOpnErr;
  141.         
  142.     return size;
  143. }
  144.  
  145. //----------------------------------------------------------------------------------------
  146. // CTidyHeapFile_AC::Write
  147. //----------------------------------------------------------------------------------------
  148.  
  149. long CTidyHeapFile_AC::Write( const char *data, long size )
  150. {
  151.     if(fRef)
  152.         fErr = ::FSWrite( fRef, &size, data );
  153.     else
  154.         fErr = fnOpnErr;
  155.  
  156.     return size;
  157. }
  158.  
  159. //----------------------------------------------------------------------------------------
  160. // CTidyHeapFile_AC::ReadObject
  161. //----------------------------------------------------------------------------------------
  162.  
  163. void CTidyHeapFile_AC::ReadObject(MTidyHeapPersistantObject_AC &inClass )
  164. {
  165.     fErr = 0;
  166.     Boolean doOpen = !IsOpen();
  167.     
  168.     if(doOpen) Open( kRead );
  169.     
  170.     if(!fErr)
  171.     {
  172.         inClass.Read(this);
  173.         if(doOpen) Close();
  174.     }
  175. }
  176.  
  177. //----------------------------------------------------------------------------------------
  178. // CTidyHeapFile_AC::WriteObject
  179. //----------------------------------------------------------------------------------------
  180.  
  181. void CTidyHeapFile_AC::WriteObject(MTidyHeapPersistantObject_AC &inClass)
  182. {
  183.     fErr = 0;
  184.     Boolean doOpen = !IsOpen();
  185.  
  186.     if(doOpen) Open( kWrite );
  187.     
  188.     if(!fErr)
  189.     {
  190.         inClass.Write(this);
  191.         if(doOpen) Close();
  192.     }
  193. }
  194.  
  195. //----------------------------------------------------------------------------------------
  196. // CTidyHeapFile_AC::SetTypeAndCreator
  197. //----------------------------------------------------------------------------------------
  198.  
  199. void CTidyHeapFile_AC::SetTypeAndCreator(OSType inType, OSType inCreator)
  200. {
  201.     fType = inType;
  202.     fCreator = inCreator;
  203. }
  204.  
  205. //----------------------------------------------------------------------------------------
  206. // CTidyHeapFile_AC::SetSpec
  207. //----------------------------------------------------------------------------------------
  208.  
  209. void CTidyHeapFile_AC::SetSpec( const FSSpec &inSpec )
  210. {
  211.     CopySpec( &fSpec, &inSpec );
  212. }
  213.  
  214. //----------------------------------------------------------------------------------------
  215. // CTidyHeapFile_AC assignment operator
  216. //----------------------------------------------------------------------------------------
  217.  
  218. CTidyHeapFile_AC &CTidyHeapFile_AC::operator = (const CTidyHeapFile_AC &inFile)
  219. {
  220.     fErr = 0;
  221.     fRef = 0;
  222.     fType = inFile.fType;
  223.     fCreator = inFile.fCreator;
  224.     CopySpec( &fSpec, &inFile.fSpec);
  225.     return *this;
  226. }
  227.  
  228. //----------------------------------------------------------------------------------------
  229. // CTidyHeapFile_AC::SetName
  230. //----------------------------------------------------------------------------------------
  231.  
  232. void CTidyHeapFile_AC::SetName( const unsigned char* inName)
  233. {
  234. #if qDebugTidyHeap
  235.     if(*inName > 31)
  236.         DebugStr("\pName too long");
  237. #endif
  238.         
  239.     pstrcpy( fSpec.name, inName );
  240. }
  241.  
  242. //----------------------------------------------------------------------------------------
  243. // CTidyHeapFile_AC::SetVolRefNum
  244. //----------------------------------------------------------------------------------------
  245.  
  246. void CTidyHeapFile_AC::SetVolRefNum( short inId)
  247. {
  248.     fSpec.vRefNum = inId;
  249. }
  250.  
  251. //----------------------------------------------------------------------------------------
  252. // CTidyHeapFile_AC::SetDirID
  253. //----------------------------------------------------------------------------------------
  254.  
  255. void CTidyHeapFile_AC::SetDirID( long inId )
  256. {
  257.     fSpec.parID = inId;
  258. }
  259.  
  260. //----------------------------------------------------------------------------------------
  261. // CTidyHeapFile_AC::GetSize
  262. //----------------------------------------------------------------------------------------
  263.     
  264. long CTidyHeapFile_AC::GetSize()
  265. {
  266.     long eof;
  267.     fErr = ::GetEOF(fRef,&eof);
  268.     return eof;
  269. }
  270.  
  271. //----------------------------------------------------------------------------------------
  272. // CTidyHeapFile_AC::AppendExtension
  273. //----------------------------------------------------------------------------------------
  274.     
  275. void CTidyHeapFile_AC::AppendExtension(const char* inExtension)
  276. {
  277.     ::p2cstr(fSpec.name);
  278.     
  279.     const short maxLen = 28;
  280.     
  281.     short len = ::strlen((char*) fSpec.name);
  282.     
  283.     if( len >= maxLen)
  284.     {
  285.         fSpec.name[maxLen] = '\0';
  286.         len = maxLen; 
  287.     }
  288.  
  289.     ::strcat((char*) fSpec.name, inExtension);
  290.     ::c2pstr((char*)fSpec.name);
  291. }
  292.  
  293. #endif